LDPC (Low Density Parity Check) codes are known error-correcting codes for approaching Shannon's theoretical limit of transmission. Because of their performance in terms of noise immunity, LDPC codes, and in particular non-binary LDPC codes, find use in the field of transmitting and storing digital data.
Non-binary LDPC codes are constructed in a non-binary Galois field of order q, conventionally written as GF(q). An LDPC code in GF(q) is defined by a sparse parity matrix H of dimensions M×N, the elements of which belong to GF(q), N being the number of GF(q) elements in the code word and M being the number of parity constraints. For a Galois field GF(4) consisting of 4 elements {0, α0, α1, α2}, the parity matrix for N=6 and M=3, for example, is as follows:
  H  =      (                            0                                      α            0                                                α            0                                    0                                      α            2                                    0                                                  α            1                                    0                          0                                      α            0                                    0                                      α            2                                                            α            0                                    0                                      α            2                                    0                          0                                      α            1                                )  
This matrix can likewise be shown by a bipartite graph (Tanner graph) having N variable nodes receiving the symbols of the code word and M parity nodes. Each column of the parity matrix is associated with a variable node and each line of the matrix is associated with a parity node. In the case of a regular LDPC code, each parity node is connected, by means of dc branches, to a single number dc of variable nodes. Similarly, each variable node is connected, by means of dv branches, to a single number dv of parity nodes. In the case of a regular LDPC code, the number dc or dv of branches varies according to the variable node or parity node.
The decoding of these LDPC codes is iterative and consists in exchanging messages via these branches, each variable or parity node processing the messages received and, after processing, delivering other messages, as the case may be, to parity nodes or variable nodes to which they are connected via branches. The exchanged messages represent probability density functions of the code symbols and are therefore in the form of vectors of size q. Such decoding is described in the document entitled “Decoding Algorithms for Nonbinary LDPC Codes Over GF(q)” by D. Declercq and M. Fossorier, Communications IEEE Transactions in Volume 55, Issue 4, April 2007, pages 633-643.
The invention specifically relates to the method for controlling parity nodes of the decoder. With reference to FIG. 1, each parity node P receives a plurality of incoming messages Ui and delivers outgoing messages Vi, with iε[0 . . . dv−1], such that
      V    j    =            ⊕              j        ≠        i              ⁢          U      i      
where ⊕ is the probability density function operator associated with the addition of the Galois field GF(q).
In the example of FIG. 1, the parity node receives dc=4 incoming messages U0, U1, U2, U3 and delivers 4 outgoing messages V0, V1, V2, V3 such as:
  {                                                             V              0                        =                                          U                1                            ⊕                              U                2                            ⊕                              U                3                                                                                                    V              1                        =                                          U                0                            ⊕                              U                2                            ⊕                              U                3                                                                                                    V              2                        =                                          U                0                            ⊕                              U                1                            ⊕                              U                3                                                                                                    V              3                        =                                          U                0                            ⊕                              U                1                            ⊕                              U                2                                                        
Each one of these calculations can be broken down into elementary calculations performed by elementary parity nodes having two inputs and one output.
For example, to calculate V0, a first elementary parity node carries out the operation U1⊕U2=Uint and then a second elementary parity node carries out the operation Uint⊕U3. It should be noted that the intermediate result Uint at the output of the first elementary parity node is likewise used to calculate V3.
In this way, each parity node can be broken down into a plurality of elementary parity nodes each receiving two incoming messages, e.g., U1 and U2, and delivering one outgoing message Uout=Uint. Such a node is shown schematically in FIG. 2. Each incoming and outgoing message is a vector of size q, associating a probability density with each element of the Galois field. In the remainder of the description, for illustrative purposes, a Galois field GF(4) is considered to consist of the elements {0, α0, α1, α2} the laws of addition and multiplication of which are defined by the following tables:
⊕0α0α1α200α0α1α2α0α00α2α1α1α1α20α0α2α2α1α00
 0α0α1α200000α00α0α1α2α10α1α2α0α20α2α0α1
The incoming messages, for example, are U1=(a0, a1, a2, a3) and U2=(b0, b1, b2, b3) where ai is the probability density function associated with the element αi in the message U1 and where bi is the probability density function associated with the element αi in the message U2, iε[0 . . . 3], with a0+a1+a2+a3=1 and b0+b1+b2+b3=1.
Taking account of the law of addition defined above for the Galois field GF(4), the outgoing message Uout is equal to Uout=(c0, c1, c2, c3) wherec0=a0·b0+a1·b1+a2·b2+a3·b3 c1=a0·b1+a1·b0+a3·b2+a2·b3 c2=a0·b2+a1·b3+a2·b0+a3·b1 c3=a0·b3+a1·b2+a2·b1+a3·b0 
Density probability functions are thus exchanged between the parity nodes and the variable nodes, and conversely, until the code word has been completely decoded. Reference is then made to a “belief propagation” algorithm.
Implementing such an algorithm is relatively complex and requires that q2 multiplications be carried out in each elementary parity node for elements belonging to GF(q).
In order to reduce this complexity, it is known to work in the logarithmic field in order to convert the multiplications into additions. The data exchanged between nodes are log likelihood ratios (LLR).
To calculate the probability density functions of the outgoing message, another known solution for reducing said complexity consists in taking account solely of the nm greatest probability density functions in the incoming messages, nm<q. This algorithm, referred to as EMS (Extended Min-Sum), is described in detail in the document entitled “Algorithmes simplifies pour le decodage de codes LDPC non binaires” de A. Voicila, D. Declercq, M. Fossorier et F. Verdier, GRETSI, Louvain-la-Neuve, Belgium, September 2005. This solution can be combined with the preceding solution such that the data exchanged are log likelihood ratios.
According to this algorithm, the incoming messages U1 and U2 are filtered and sorted prior to being processed by the elementary parity node. The messages supplied to the elementary parity node are then lists comprising only nm probability density function values or LLR sorted in descending order, each probability density function or LLR value being associated with an element of the Galois field GF(q). The number of probability function or LLR values taken into account by the elementary parity node being reduced (nm<q), the complexity of this algorithm is reduced but remains high nonetheless. A method employing an algorithm enabling the number of calculations in the elementary parity nodes to be yet further reduced would present decided advantages.